

// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   ep.java

package com.zelix;

import java.util.*;

// Referenced classes of package com.zelix:
//            ht, it, fh, ko, 
//            xb, wb, bc, zo, 
//            m5, dp, fp, gp, 
//            lt, iu, lx, px, 
//            qx, qb, fy, wu, 
//            qy, sy, tb, nh, 
//            um, nt, ou

public final class ep
{

    private static final fp a;
    private static final fp b;
    private static final fp c;
    private ko d;
    private boolean h;
    private nh e;
    private fy f;
    private fy g;
    private fy i;
    private qy j;
    private fy k;
    private fy l;
    private Hashtable m;
    private HashSet n;
    private fy o;
    private static String z[];

    ep(it it1, ht ht1, ko ko1, um um, int i1, boolean flag, nh nh)
        throws qb, bc
    {
        j = new qy();
        l = new fy();
        m = new Hashtable();
        n = new HashSet();
        o = new fy();
        d = ko1;
        h = flag;
        e = nh;
        k = new fy(i1, 20);
        f = new fy(i1, 50);
        g = new fy(i1, 50);
        i = new fy(101, 37);
        a(it1, ht1);
    }

    public final Object a(String s, dp dp1, lt lt1)
    {
        return g.b(s, dp1, lt1);
    }

    public final Hashtable a(String s, Hashtable hashtable)
    {
        return g.a(s, hashtable);
    }

    public final Object b(String s, dp dp1, lt lt1)
    {
        return f.b(s, dp1, lt1);
    }

    public final Hashtable b(String s, Hashtable hashtable)
    {
        return f.a(s, hashtable);
    }

    private void a(it it1, ht ht1)
        throws qb, bc
    {
        Vector vector;
        int i1;
        int j1;
        boolean flag1;
        flag1 = tb.b;
        vector = ht1.i();
        i1 = vector.size();
        j1 = 0;
        if(!flag1) goto _L2; else goto _L1
_L1:
        fh fh1 = (fh)vector.elementAt(j1);
        mt mt = fh1.c();
        String s = mt.j();
        a(s, ((String) (null)));
        fh1.a(this);
        j1++;
_L2:
        if(j1 < i1) goto _L1; else goto _L3
_L3:
        sy sy1;
        fy fy1;
        fy fy2;
        int k1;
        sy1 = new sy();
        fy1 = new fy();
        fy2 = new fy();
        k1 = 0;
        if(!flag1) goto _L5; else goto _L4
_L4:
        Object obj;
        Object obj3;
        Object obj4;
        obj = (fh)vector.elementAt(k1);
        mt mt1 = ((fh) (obj)).c();
        if(!mt1.E())
            continue; /* Loop/switch isn't completed */
        String s1 = mt1.j();
        obj3 = c(s1);
        obj4 = ((Hashtable) (obj3)).keys();
        if(!flag1) goto _L7; else goto _L6
_L6:
        dp dp1 = (dp)((Enumeration) (obj4)).nextElement();
        lt lt1 = (lt)((Hashtable) (obj3)).get(dp1);
        fh fh4 = fh.b(lt1.j());
        if(fh4 != null && fh4.w())
        {
            sy1.b(dp1, fh4, obj);
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        fy2.b(obj, dp1, lt1);
_L7:
        if(((Enumeration) (obj4)).hasMoreElements()) goto _L6; else goto _L8
_L8:
        Vector vector1 = new Vector();
        j.a(obj, vector1);
        a(((fh) (obj)), ((fh) (obj)), true, vector1, fy1);
        fy1.b(obj, obj, "s");
        k1++;
_L5:
        if(k1 < i1) goto _L4; else goto _L9
_L9:
        obj = sy1.b();
        if(!flag1) goto _L11; else goto _L10
_L10:
        Object obj1;
        Object obj2;
        obj1 = (dp)((Enumeration) (obj)).nextElement();
        obj2 = sy1.b(obj1);
        obj3 = new Vector();
        obj4 = ((qy) (obj2)).e();
        if(!flag1) goto _L13; else goto _L12
_L12:
        fh fh2 = (fh)((Enumeration) (obj4)).nextElement();
        qx qx1 = new qx();
        a(qx1, fh2, ((qy) (obj2)));
        ((Vector) (obj3)).addElement(qx1);
_L13:
        if(((Enumeration) (obj4)).hasMoreElements()) goto _L12; else goto _L14
_L14:
        obj4 = ((qy) (obj2)).e();
        if(!flag1) goto _L16; else goto _L15
_L15:
        fh fh3;
        Object obj5;
        Object obj6;
        int i2;
        fh3 = (fh)((Enumeration) (obj4)).nextElement();
        obj5 = (Vector)((Vector) (obj3)).clone();
        obj6 = null;
        i2 = 0;
          goto _L17
_L21:
        Object obj8;
        Object obj9;
        obj8 = (qx)((Vector) (obj5)).elementAt(i2);
        if(!((qx) (obj8)).a(fh3))
            continue; /* Loop/switch isn't completed */
        if(obj6 == null)
        {
            obj6 = obj8;
            if(!flag1)
                continue; /* Loop/switch isn't completed */
        }
        obj9 = ((qx) (obj8)).a();
        if(!flag1) goto _L19; else goto _L18
_L18:
        Object obj10 = ((Enumeration) (obj9)).nextElement();
        ((qx) (obj6)).a(obj10, obj10);
_L19:
        if(((Enumeration) (obj9)).hasMoreElements()) goto _L18; else goto _L20
_L20:
        boolean flag = ((Vector) (obj3)).removeElement(obj8);
        i2++;
_L17:
        if(i2 < ((Vector) (obj5)).size()) goto _L21; else goto _L16
_L16:
        if(((Enumeration) (obj4)).hasMoreElements()) goto _L15; else goto _L22
_L22:
        int l1 = 0;
        if(!flag1) goto _L24; else goto _L23
_L23:
        wu wu1;
        obj5 = (qx)((Vector) (obj3)).elementAt(l1);
        obj6 = new Vector(((qx) (obj5)).b());
        wu1 = new wu(obj6);
        m.put(wu1, new wu());
        obj8 = ((qx) (obj5)).a();
        if(!flag1) goto _L26; else goto _L25
_L25:
        obj9 = (fh)((Enumeration) (obj8)).nextElement();
        ((Vector) (obj6)).addElement(obj9);
        l.b(obj9, obj1, wu1);
_L26:
        if(((Enumeration) (obj8)).hasMoreElements()) goto _L25; else goto _L27
_L27:
        int j2;
        obj9 = null;
        j2 = 0;
        if(!flag1) goto _L29; else goto _L28
_L28:
        fh fh5 = (fh)((Vector) (obj6)).elementAt(j2);
        lt lt2 = (lt)fy2.b(fh5, obj1);
        if(lt2 == null)
            continue; /* Loop/switch isn't completed */
        obj9 = lt2;
        break; /* Loop/switch isn't completed */
        j2++;
_L29:
        if(j2 < ((Vector) (obj6)).size()) goto _L28; else goto _L30
_L30:
        if(obj9 != null) goto _L32; else goto _L31
_L31:
        int k2 = 0;
        if(!flag1) goto _L34; else goto _L33
_L33:
        fh fh6 = (fh)((Vector) (obj6)).elementAt(k2);
        mt mt2 = fh6.c();
        if(!it1.a(((dp) (obj1)), mt2))
            continue; /* Loop/switch isn't completed */
        obj9 = mt2;
        if(!flag1)
            break; /* Loop/switch isn't completed */
        k2++;
_L34:
        if(k2 < ((Vector) (obj6)).size()) goto _L33; else goto _L32
_L32:
        lx.b(obj9, z[4] + obj1 + " " + obj6);
        k2 = 0;
        if(!flag1) goto _L36; else goto _L35
_L35:
        fh fh7 = (fh)((Vector) (obj6)).elementAt(k2);
        i.b(fh7.d(), obj1, obj9);
        k2++;
_L36:
        if(k2 < ((Vector) (obj6)).size()) goto _L35; else goto _L37
_L37:
        l1++;
_L24:
        if(l1 < ((Vector) (obj3)).size()) goto _L23; else goto _L11
_L11:
        if(((Enumeration) (obj)).hasMoreElements()) goto _L10; else goto _L38
_L38:
        obj1 = fy1.e();
        if(!flag1) goto _L40; else goto _L39
_L39:
        obj2 = (Hashtable)((Enumeration) (obj1)).nextElement();
        if(((Hashtable) (obj2)).size() <= 1)
            continue; /* Loop/switch isn't completed */
        obj3 = ((Hashtable) (obj2)).keys();
        if(!flag1) goto _L42; else goto _L41
_L41:
        obj4 = ((Enumeration) (obj3)).nextElement();
        String s2 = (String)((Hashtable) (obj2)).get(obj4);
        if(s2.equals("d"))
            continue; /* Loop/switch isn't completed */
        obj5 = ((Hashtable) (obj2)).keys();
        if(!flag1) goto _L44; else goto _L43
_L43:
        Object obj7 = ((Enumeration) (obj5)).nextElement();
        if(obj4 != obj7)
            o.b(obj4, obj7, obj7);
_L44:
        if(((Enumeration) (obj5)).hasMoreElements()) goto _L43; else goto _L42
_L42:
        if(((Enumeration) (obj3)).hasMoreElements()) goto _L41; else goto _L40
_L40:
        if(((Enumeration) (obj1)).hasMoreElements()) goto _L39; else goto _L45
_L45:
    }

    public final Vector a(fh fh1)
    {
        return j.d(fh1);
    }

    public final Hashtable a(String s, String s1)
        throws qb, bc
    {
        Hashtable hashtable;
label0:
        {
            Object obj;
label1:
            {
                fh fh1 = fh.b(s);
                boolean flag = fh1 != null && fh1.w();
                hashtable = d(s);
                if(hashtable != null)
                    break label0;
                if(!flag)
                {
                    obj = b(s);
                    if(!tb.b)
                        break label1;
                }
                obj = fh1.c();
            }
            hashtable = ((lt) (obj)).a(this);
        }
        return hashtable;
    }

    final nt b(String s)
        throws bc
    {
        try
        {
            nt nt = d.a(s);
            return nt;
        }
        catch(xb xb1)
        {
            throw new bc(z[0] + lt.a(xb1.a()) + z[1]);
        }
        catch(wb wb1)
        {
            throw new bc(wb1.getMessage());
        }
    }

    private Hashtable c(String s)
    {
        return g.b(s);
    }

    private Hashtable d(String s)
    {
        return f.b(s);
    }

    public final lt a(String s, dp dp1)
    {
        HashSet hashset;
        lt lt1;
        lt lt2;
        boolean flag;
        flag = tb.b;
        hashset = null;
        lt1 = (lt)g.b(s, dp1);
        lt2 = null;
          goto _L1
_L6:
        StringBuffer stringbuffer;
        Iterator iterator;
        lt2 = lt1;
        lt1 = (lt)g.b(lt1.j(), dp1);
        if(lt1 == null)
            continue; /* Loop/switch isn't completed */
        if(hashset == null)
            hashset = new HashSet(13);
        if(hashset.add(lt1))
            continue; /* Loop/switch isn't completed */
        stringbuffer = new StringBuffer();
        iterator = hashset.iterator();
        if(!flag) goto _L3; else goto _L2
_L2:
        lt lt3 = (lt)iterator.next();
        stringbuffer.append("'" + lt3.j() + "'");
        if(iterator.hasNext())
            stringbuffer.append(z[3]);
_L3:
        if(iterator.hasNext()) goto _L2; else goto _L4
_L4:
        lx.b(false, z[2] + dp1 + zo.e + stringbuffer);
_L1:
        if(lt1 != null) goto _L6; else goto _L5
_L5:
        return lt2;
    }

    public final String a(wu wu1)
    {
        return (String)((wu)m.get(wu1)).a();
    }

    Hashtable a()
    {
        Hashtable hashtable;
        Enumeration enumeration;
        boolean flag;
        flag = tb.b;
        hashtable = new Hashtable();
        enumeration = l.d();
        if(!flag) goto _L2; else goto _L1
_L1:
        Hashtable hashtable1;
        Enumeration enumeration1;
        fh fh1 = (fh)enumeration.nextElement();
        hashtable1 = l.b(fh1);
        enumeration1 = hashtable1.keys();
        if(!flag) goto _L4; else goto _L3
_L3:
        dp dp1 = (dp)enumeration1.nextElement();
        wu wu1 = (wu)hashtable1.get(dp1);
        Object obj = hashtable.put(wu1, dp1);
_L4:
        if(enumeration1.hasMoreElements()) goto _L3; else goto _L2
_L2:
        if(!enumeration.hasMoreElements())
            return hashtable;
        if(true) goto _L1; else goto _L5
_L5:
    }

    final wu a(fh fh1, dp dp1)
    {
        return (wu)l.b(fh1, dp1);
    }

    public final lt b(String s, dp dp1)
    {
        lt lt1 = (lt)i.b(s, dp1);
        if(lt1 != null)
            return lt1;
        lt1 = (lt)g.b(s, dp1);
        lt lt2 = null;
        for(; lt1 != null; lt1 = (lt)g.b(lt1.j(), dp1))
        {
            lt2 = lt1;
            lt lt3 = (lt)i.b(lt1.j(), dp1);
            if(lt3 != null)
                return lt3;
        }

        return lt2;
    }

    public final void a(dp dp1)
    {
        Object obj;
label0:
        {
            if(h)
            {
                obj = dp1;
                if(!tb.b)
                    break label0;
            }
            obj = dp1.a();
        }
        n.add(obj);
    }

    public final boolean b(dp dp1)
    {
        Object obj;
label0:
        {
            if(h)
            {
                obj = dp1;
                if(!tb.b)
                    break label0;
            }
            obj = dp1.a();
        }
        return n.contains(obj);
    }

    private boolean c(String s, dp dp1)
    {
        return g.a(s, dp1);
    }

    public final boolean b(fh fh1, dp dp1)
    {
        Object obj;
label0:
        {
            if(h)
            {
                obj = dp1;
                if(!tb.b)
                    break label0;
            }
            obj = dp1.a();
        }
        return k.a(fh1, obj);
    }

    public final boolean a(fh fh1, dp dp1, dp dp2)
    {
        Object obj;
        Object obj1;
label0:
        {
            if(h)
            {
                obj = dp2;
                obj1 = dp1;
                if(!tb.b)
                    break label0;
            }
            obj = dp2.a();
            obj1 = dp1.a();
        }
        fp fp1 = (fp)k.b(fh1, obj1);
        if(fp1 == null)
            return false;
        else
            return fp1.a.equals(obj) ^ true;
    }

    private void a(qx qx1, fh fh1, qy qy1)
    {
        Vector vector;
        boolean flag;
        flag = tb.b;
        Object obj = qx1.a(fh1, fh1);
        if(obj != null)
            return;
        vector = qy1.d(fh1);
        if(vector == null) goto _L2; else goto _L1
_L1:
        int i1 = 0;
        if(!flag) goto _L4; else goto _L3
_L3:
        fh fh2 = (fh)vector.elementAt(i1);
        a(qx1, fh2, qy1);
        i1++;
_L4:
        if(i1 < vector.size()) goto _L3; else goto _L2
_L2:
    }

    final void a(fh fh1, fh fh2, boolean flag, Vector vector, fy fy1)
    {
        boolean flag1 = tb.b;
        if(!flag || fh2.v()) goto _L2; else goto _L1
_L1:
        Object obj;
        int i1;
        flag = false;
        obj = new Vector(5);
        fh2.a(((Vector) (obj)));
        i1 = 0;
        if(!flag1) goto _L4; else goto _L3
_L3:
        fh fh4 = (fh)((Vector) (obj)).elementAt(i1);
        if(fy1.a(fh4, fh1) && !flag1)
            break; /* Loop/switch isn't completed */
        fy1.b(fh4, fh1, "d");
        vector.addElement(fh4);
        i1++;
_L4:
        if(i1 < ((Vector) (obj)).size()) goto _L3; else goto _L2
_L2:
        obj = fh2.p();
        if(obj == null) goto _L6; else goto _L5
_L5:
        if(!flag1) goto _L8; else goto _L7
_L7:
        fh fh3 = (fh)((Enumeration) (obj)).nextElement();
        fy1.b(fh3, fh1, "i");
        a(fh1, fh3, flag, vector, fy1);
        vector.addElement(fh3);
_L8:
        if(((Enumeration) (obj)).hasMoreElements()) goto _L7; else goto _L6
_L6:
        Enumeration enumeration = fh2.l();
        if(enumeration == null) goto _L10; else goto _L9
_L9:
        if(!flag1) goto _L12; else goto _L11
_L11:
        fh fh5 = (fh)enumeration.nextElement();
        fy1.b(fh5, fh1, "i");
        a(fh1, fh5, flag, vector, fy1);
        if(!fh5.v())
            vector.addElement(fh5);
_L12:
        if(enumeration.hasMoreElements()) goto _L11; else goto _L10
_L10:
    }

    private void a(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1)
    {
        Object obj;
        int i1;
        boolean flag;
        flag = tb.b;
        wu wu1 = a(fh1, new dp(m5_2));
        if(wu1 == null)
            break MISSING_BLOCK_LABEL_84;
        obj = (Vector)wu1.a();
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        fh fh3 = (fh)((Vector) (obj)).elementAt(i1);
        Object obj1 = hashtable.put(fh3, fh3);
        i1++;
_L2:
        if(i1 < ((Vector) (obj)).size()) goto _L1; else goto _L3
_L3:
        if(!flag)
            break MISSING_BLOCK_LABEL_93;
        obj = hashtable.put(fh1, fh1);
        obj = hashtable.keys();
        if(!flag) goto _L5; else goto _L4
_L4:
        fh fh2 = (fh)((Enumeration) (obj)).nextElement();
        a(fh2, hashtable1);
_L5:
        if(!((Enumeration) (obj)).hasMoreElements())
            return;
        if(true) goto _L4; else goto _L6
_L6:
    }

    private boolean a(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1, Hashtable hashtable2, ou ou)
    {
        boolean flag;
        int i1;
label0:
        {
            flag = tb.b;
            if(ou.A())
            {
                i1 = a(fh1, m5_1);
                if(!flag)
                    break label0;
            }
            if(ou.D())
            {
                i1 = b(fh1, m5_1);
                if(!flag)
                    break label0;
            }
            i1 = a(fh1, m5_1, m5_2);
        }
        switch(i1)
        {
        case -1: 
            a(hashtable, hashtable1, m5_1);
            return false;

        case 0: // '\0'
            hashtable.put(fh1, fh1);
            // fall through

        case 1: // '\001'
        case 2: // '\002'
        default:
            fh1.b(hashtable2);
            break;
        }
        if(ou.A() || ou.D()) goto _L2; else goto _L1
_L1:
        Enumeration enumeration = fh1.p();
        if(enumeration == null) goto _L2; else goto _L3
_L3:
        if(!flag) goto _L5; else goto _L4
_L4:
        fh fh2 = (fh)enumeration.nextElement();
        if(!a(fh2, m5_1, m5_2, hashtable, hashtable1, hashtable2, ou))
            return false;
_L5:
        if(enumeration.hasMoreElements()) goto _L4; else goto _L2
_L2:
        return true;
    }

    private boolean b(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1, Hashtable hashtable2, ou ou)
    {
label0:
        {
            fh fh2;
            int i1;
            boolean flag;
label1:
            {
                flag = tb.b;
                fh2 = fh1.q();
                if(fh2 == null)
                    break label0;
                if(ou.A())
                {
                    i1 = a(fh2, m5_1);
                    if(!flag)
                        break label1;
                }
                if(ou.D())
                {
                    i1 = b(fh2, m5_1);
                    if(!flag)
                        break label1;
                }
                i1 = a(fh2, m5_1, m5_2, hashtable1);
            }
            switch(i1)
            {
            default:
                break;

            case -1: 
                a(hashtable, hashtable1, m5_1);
                return false;

            case 0: // '\0'
                hashtable.put(fh2, fh2);
                if(!flag)
                    break;
                // fall through

            case 1: // '\001'
            case 2: // '\002'
                return true;
            }
            fh2.b(hashtable2);
            if(!b(fh2, m5_1, m5_2, hashtable, hashtable1, hashtable2, ou))
                return false;
        }
        return true;
    }

    private void a(fh fh1, Hashtable hashtable)
    {
        Hashtable hashtable1;
        boolean flag;
        flag = tb.b;
        hashtable1 = o.b(fh1);
        if(hashtable1 == null) goto _L2; else goto _L1
_L1:
        Enumeration enumeration = hashtable1.keys();
        if(!flag) goto _L4; else goto _L3
_L3:
        fh fh2 = (fh)enumeration.nextElement();
        hashtable.put(fh2, fh2);
_L4:
        if(enumeration.hasMoreElements()) goto _L3; else goto _L2
_L2:
    }

    private boolean b(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1)
    {
        int i1 = a(fh1, m5_1, m5_2, hashtable1);
        switch(i1)
        {
        case -1: 
            a(hashtable, hashtable1, m5_1);
            return false;

        case 0: // '\0'
            hashtable.put(fh1, fh1);
            // fall through

        case 1: // '\001'
        case 2: // '\002'
        default:
            return true;
        }
    }

    final boolean b(fh fh1, dp dp1, dp dp2)
    {
        Object obj;
        Object obj1;
        Hashtable hashtable1;
        Hashtable hashtable2;
        Hashtable hashtable3;
        Enumeration enumeration;
        boolean flag;
label0:
        {
            flag = tb.b;
            if(h)
            {
                obj = dp1;
                obj1 = dp2;
                if(!flag)
                    break label0;
            }
            obj = dp1.a();
            obj1 = dp2.a();
        }
        Hashtable hashtable = new Hashtable();
        hashtable1 = new Hashtable();
        a(fh1, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1);
        hashtable2 = new Hashtable(px.a(hashtable.size() + hashtable1.size()));
        hashtable3 = new Hashtable();
        enumeration = hashtable.keys();
        if(!flag) goto _L2; else goto _L1
_L1:
        fh fh2 = (fh)enumeration.nextElement();
        int i1 = a(fh2, ((m5) (obj)), ((m5) (obj1)));
        switch(i1)
        {
        case -1: 
            a(hashtable2, hashtable3, ((m5) (obj)));
            return false;

        case 0: // '\0'
            hashtable2.put(fh2, fh2);
            break;
        }
        if(!c(fh2, ((m5) (obj)), ((m5) (obj1)), hashtable2, hashtable3))
            return false;
_L2:
        if(enumeration.hasMoreElements()) goto _L1; else goto _L3
_L3:
        Enumeration enumeration1 = hashtable1.keys();
        if(!flag) goto _L5; else goto _L4
_L4:
        fh fh3 = (fh)enumeration1.nextElement();
        int j1 = a(fh3, ((m5) (obj)), ((m5) (obj1)), hashtable3);
        switch(j1)
        {
        case -1: 
            a(hashtable2, hashtable3, ((m5) (obj)));
            return false;

        case 0: // '\0'
            hashtable2.put(fh3, fh3);
            break;
        }
_L5:
        if(!enumeration1.hasMoreElements())
            return true;
        if(true) goto _L4; else goto _L6
_L6:
    }

    final boolean a(fh fh1, dp dp1, dp dp2, ou ou)
    {
        Object obj;
        Object obj1;
        Hashtable hashtable;
        Hashtable hashtable1;
        Enumeration enumeration;
        boolean flag1;
label0:
        {
            flag1 = tb.b;
            if(h)
            {
                obj = dp1;
                obj1 = dp2;
                if(!flag1)
                    break label0;
            }
            obj = dp1.a();
            obj1 = dp2.a();
        }
        Hashtable hashtable2;
        boolean flag;
label1:
        {
            hashtable = new Hashtable();
            hashtable1 = new Hashtable();
            hashtable2 = new Hashtable(17);
            flag = a(fh1, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1, hashtable2, ou);
            if(flag)
            {
                flag = b(fh1, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1, hashtable2, ou);
                if(!flag1)
                    break label1;
            }
            return false;
        }
        if(!flag)
            break MISSING_BLOCK_LABEL_177;
        enumeration = hashtable2.keys();
        if(!flag1) goto _L2; else goto _L1
_L1:
        fh fh2 = (fh)enumeration.nextElement();
        if(!b(fh2, ((m5) (obj)), ((m5) (obj1)), hashtable, hashtable1))
            return false;
_L2:
        if(enumeration.hasMoreElements()) goto _L1; else goto _L3
_L3:
        if(!flag1)
            break MISSING_BLOCK_LABEL_179;
        return false;
        return true;
    }

    private int a(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable)
    {
        if(!fh1.w())
            return 2;
        fp fp1 = (fp)k.b(fh1, m5_1, a);
        if(fp1 == null)
            return 0;
        if(fp1 == c || fp1 == b)
        {
            gp gp1 = new gp(fh1, fp1);
            hashtable.put(gp1, gp1);
            return 0;
        }
        if(fp1 == a)
            return 1;
        if(fp1.a != null && fp1.a.equals(m5_2))
        {
            k.b(fh1, m5_1, fp1);
            return 1;
        } else
        {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private int a(fh fh1, m5 m5_1)
    {
        if(!fh1.w())
            return 2;
        fp fp1 = (fp)k.b(fh1, m5_1, c);
        if(fp1 == null)
            return 0;
        if(fp1 == c)
            return 1;
        if(fp1 == b)
        {
            k.b(fh1, m5_1, fp1);
            return 1;
        }
        if(fp1 == a)
        {
            k.b(fh1, m5_1, a);
            return 1;
        }
        if(fp1.a != null && fp1.b == 3)
        {
            k.b(fh1, m5_1, fp1);
            return 1;
        } else
        {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private int b(fh fh1, m5 m5_1)
    {
        if(!fh1.w())
            return 2;
        fp fp1 = (fp)k.b(fh1, m5_1, b);
        if(fp1 == null)
            return 0;
        if(fp1 == c)
        {
            k.b(fh1, m5_1, fp1);
            return 1;
        }
        if(fp1 == b)
            return 1;
        if(fp1 == a)
        {
            k.b(fh1, m5_1, a);
            return 1;
        } else
        {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private int a(fh fh1, m5 m5_1, m5 m5_2)
    {
        if(!fh1.w())
            return 2;
        fp fp1 = (fp)k.b(fh1, m5_1, new fp(m5_2));
        if(fp1 == null)
            return 0;
        if(fp1.a != null && fp1.a.equals(m5_2))
        {
            return 1;
        } else
        {
            k.b(fh1, m5_1, fp1);
            return -1;
        }
    }

    private boolean c(fh fh1, m5 m5_1, m5 m5_2, Hashtable hashtable, Hashtable hashtable1)
    {
        Vector vector;
        boolean flag;
        flag = tb.b;
        vector = a(fh1);
        if(vector == null) goto _L2; else goto _L1
_L1:
        int i1 = 0;
        if(!flag) goto _L4; else goto _L3
_L3:
        int j1;
label0:
        {
            fh fh2 = (fh)vector.elementAt(i1);
            if(c(fh2.d(), new dp(m5_2)))
            {
                j1 = a(fh2, m5_1, m5_2);
                if(!flag)
                    break label0;
            }
            j1 = a(fh2, m5_1, m5_2, hashtable1);
        }
        switch(j1)
        {
        case -1: 
            a(hashtable, hashtable1, m5_1);
            return false;

        case 0: // '\0'
            hashtable.put(fh1, fh1);
            // fall through

        case 1: // '\001'
        case 2: // '\002'
        default:
            i1++;
            break;
        }
_L4:
        if(i1 < vector.size()) goto _L3; else goto _L2
_L2:
        return true;
    }

    final boolean a(wu wu1, dp dp1, dp dp2)
    {
        Vector vector;
        Object obj;
        Object obj1;
        Hashtable hashtable;
        Hashtable hashtable1;
        int i1;
        boolean flag;
label0:
        {
            flag = tb.b;
            vector = (Vector)wu1.a();
            if(h)
            {
                obj = dp1;
                obj1 = dp2;
                if(!flag)
                    break label0;
            }
            obj = dp1.a();
            obj1 = dp2.a();
        }
        hashtable = new Hashtable();
        hashtable1 = new Hashtable();
        i1 = 0;
        if(!flag) goto _L2; else goto _L1
_L1:
        fh fh1 = (fh)vector.elementAt(i1);
        int j1 = a(fh1, ((m5) (obj)), ((m5) (obj1)));
        switch(j1)
        {
        case -1: 
            a(hashtable, hashtable1, ((m5) (obj)));
            return false;

        case 0: // '\0'
            hashtable.put(fh1, fh1);
            // fall through

        case 1: // '\001'
        case 2: // '\002'
        default:
            i1++;
            break;
        }
_L2:
        if(i1 >= vector.size())
        {
            a(wu1, ((m5) (obj)).c());
            return true;
        }
        if(true) goto _L1; else goto _L3
_L3:
    }

    private void a(Hashtable hashtable, Hashtable hashtable1, m5 m5_1)
    {
        Enumeration enumeration;
        boolean flag;
        flag = tb.b;
        enumeration = hashtable.keys();
        if(!flag) goto _L2; else goto _L1
_L1:
        Object obj = enumeration.nextElement();
        Object obj1 = k.c(obj, m5_1);
_L2:
        if(enumeration.hasMoreElements()) goto _L1; else goto _L3
_L3:
        Enumeration enumeration1 = hashtable1.keys();
        if(!flag) goto _L5; else goto _L4
_L4:
        gp gp1 = (gp)enumeration1.nextElement();
        Object obj2 = k.b(gp1.a, m5_1, gp1.b);
_L5:
        if(!enumeration1.hasMoreElements())
            return;
        if(true) goto _L4; else goto _L6
_L6:
    }

    public final void a(wu wu1, String s)
    {
        wu wu2 = (wu)m.get(wu1);
        wu2.a(s);
    }

    private static String z(char[] chs) {
        byte key = 0;
        for (int i = 0; i < chs.length; i++) {
            switch (i % 5) {
                case 0:
                    key =24;
                    break;
                case 1:
                    key =55;
                    break;
                case 2:
                    key =57;
                    break;
                case 3:
                    key =21;
                    break;
                case 4:
                    key =77;
                    break;
            }
            chs[i] ^= key;
        }
        return new String(chs).intern();
    }

    static
    {
        String as[];
        as = new String[5];
        as[0] = z("g[Xf>\004\020".toCharArray());
        as[1] = z("\003\027Wz9\004QV`#@\031\031=|\r".toCharArray());
        as[2] = z("hxvEm@RMp.PR];c\n".toCharArray());
        as[3] = z("\b\027".toCharArray());
        as[4] = z("bVPy(@\027MzmB^Wqm@R\\x(@\027]p9AET|#MY^5$JC\\g+ET\\5".toCharArray());
        z = as;
        a = new fp(1);
        b = new fp(2);
        c = new fp(3);
    }
}